机器学习

神经网络

计算机学院    张腾

tengzhang@hust.edu.cn

大纲

发展历史

• 八十年代红极一时：x86 系列 CPU 和内存条技术较七十年代显著提高
• 近十年梅开二度：大数据防止过拟合，显卡等计算设备性能显著提升

神经网络

• 黄色部分就是个 M-P 神经元模型
• 大量的神经元并行串联就构成了神经网络
• 只要存在隐藏层，神经网络就拥有了非线性分类能力

形式化

引入下面的记号：

• $L$：神经网络的层数
• $n_l$：第$l$层神经元的个数
• $h_l(\cdot)$：第$l$层的激活函数
• $\Wv_l \in \Rbb^{n_l \times n_{l-1}}$：第$l-1$层到第$l$层的权重矩阵
• $\bv_l \in \Rbb^{n_l}$：第$l$层的偏置 (截距)
• $\zv_l \in \Rbb^{n_l}$：第$l$层神经元的输入
• $\av_l \in \Rbb^{n_l}$：第$l$层神经元的输出

神经网络第$l$层的计算过程：$\zv_l = \Wv_l \av_{l-1} + \bv_l$，$\av_l = h_l (\zv_l)$

整个网络：$\xv = \av_0 \xrightarrow{\Wv_1,\bv_1} \zv_1 \xrightarrow{h_1} \av_1 \xrightarrow{\Wv_2,\bv_2} \cdots \xrightarrow{\Wv_L,\bv_L} \zv_L \xrightarrow{h_L} \av_L = \hat{\yv}$

激活函数

最早的 M-P 模型采用阶跃函数$\sgn(\cdot)$作为激活函数

改进方向：

• 连续并几乎处处可导，可以高效计算
• 导数的值域在合适的范围内，否则影响用梯度下降进行训练

常见的有

• Sigmoid 型：对率函数，双曲正切函数
• ReLU，带泄漏的 ReLU，带参数的 ReLU，ELU，Softplus
• Swish 函数
• Maxout 单元

Sigmoid 型

对率函数

将$\Rbb$挤压到$[0,1]$，输出拥有概率意义：

$$ \begin{align*} \quad \sigma(z) = \frac{1}{1 + \exp (-z)} = \begin{cases} 1, & z \rightarrow \infty \\ 0, & z \rightarrow -\infty \end{cases} \end{align*} $$

对率函数连续可导，在零处导数最大

$$ \begin{align*} \quad \nabla \sigma(z) = \sigma(z) (1 - \sigma(z)) \le \left( \frac{\sigma(z) + 1 - \sigma(z)}{2} \right)^2 = \frac{1}{4} \end{align*} $$

均值不等式等号成立的条件是$\sigma(z) = 1 - \sigma(z)$，即$z = 0$

双曲正切函数

将$\Rbb$挤压到$[-1,1]$，输出零中心化，对率函数的放大平移

$$ \begin{align*} \quad \tanh(z) & = \frac{\exp(z) - \exp(-z)}{\exp(z) + \exp(-z)} = \frac{1 - \exp(-2z)}{1 + \exp(-2z)} = 2 \sigma(2z) - 1 \\[2pt] & = \begin{cases} 1, & z \rightarrow \infty \\ -1, & z \rightarrow -\infty \end{cases} \\[10pt] \nabla \tanh(z) & = 4 \sigma(2z) (1 - \sigma(2z)) \le 1 \end{align*} $$

双曲正切函数连续可导，在$z = 0$处导数最大

输出零中心化使得非输入层的输入都在零附近，而双曲正切函数在零处导数最大，梯度下降更新效率较高，对率函数输出恒为正，会减慢梯度下降的收敛速度

整流线性单元

整流线性单元 (rectified linear unit, ReLU)：

$$ \begin{align*} \quad \relu(z) = \max \{ 0, z \} = \begin{cases} z & z \ge 0 \\ 0 & z < 0 \end{cases} \end{align*} $$

优点

• 计算只涉及加法、乘法和比较操作，非常高效
• 生物学解释：单侧抑制，宽兴奋边界，稀疏兴奋
• 在$z > 0$时导数恒为$1$，缓解了梯度消失问题

缺点

• 输出非零中心化，对下一层不友好
• 死亡 ReLU 问题：对异常值特别敏感

死亡 ReLU 问题

由链式法则有

$$ \begin{align*} \quad \nabla_{\wv} \relu(\wv^\top \xv + b) & = \frac{\partial \relu(\wv^\top \xv + b)}{\partial (\wv^\top \xv + b)} \frac{\partial (\wv^\top \xv + b)}{\partial \wv} \\ & = \frac{\partial \max \{ 0, \wv^\top \xv + b \}}{\partial (\wv^\top \xv + b)} \xv \\ & = \Ibb(\wv^\top \xv + b \ge 0) \xv \end{align*} $$

如果第一个隐藏层中的某个神经元对应的$(\wv,b)$初始化不当，使得对任意$\xv$有$\wv^\top \xv + b < 0$，那么其关于$(\wv,b)$的梯度将为零，在以后的训练过程中永远不会被更新

解决方案：带泄漏的 ReLU，带参数的 ReLU，ELU，Softplus

ReLU 变体

带泄漏的 ReLU：当$\wv^\top \xv + b < 0$时也有非零梯度

$$ \begin{align*} \quad \lrelu(z) & = \begin{cases} z & z \ge 0 \\ \gamma z & z < 0 \end{cases} \\ & = \max \{ 0, z \} + \gamma \min \{ 0, z \} \overset{\gamma < 1}{=} \max \{ z, \gamma z \} \end{align*} $$

其中斜率$\gamma$是一个很小的常数，比如$0.01$

带参数的 ReLU：斜率$\gamma_i$可学习

$$ \begin{align*} \quad \prelu(z) & = \begin{cases} z & z \ge 0 \\ \gamma_i z & z < 0 \end{cases} \\[4pt] & = \max \{ 0, z \} + \gamma_i \min \{ 0, z \} \end{align*} $$

可以不同神经元有不同的参数，也可以一组神经元共享一个参数

ReLU 变体

指数线性单元 (exponential linear unit, ELU)

$$ \begin{align*} \quad \elu(z) & = \begin{cases} z & z \ge 0 \\ \gamma (\exp(z) - 1) & z < 0 \end{cases} \\[4pt] & = \max \{ 0, z \} + \min \{ 0, \gamma (\exp(z) - 1) \} \end{align*} $$

Softplus 函数可以看作 ReLU 的平滑版本：

$$ \begin{align*} \quad \softplus(z) = \ln (1 + \exp(z)) \end{align*} $$

其导数为对率函数

$$ \begin{align*} \quad \nabla \softplus(z) = \frac{\exp(z)}{1 + \exp(z)} = \frac{1}{1 + \exp(-z)} \end{align*} $$

ReLU 族

Swish 函数

Swish 函数是一种自门控 (self-gated) 激活函数：

$$ \begin{align*} \quad \swish(z) = z \cdot \sigma (\beta z) = \frac{z}{1 + \exp(-\beta z)} \end{align*} $$

其中$\beta$是一个可学习的参数

• 当$\sigma (\beta z)$接近于$1$时，门处于开状态，激活函数的输出近似于$z$本身
• 当$\sigma (\beta z)$接近于$0$时，门处于关状态，激活函数的输出近似于$0$

Swish 函数

Maxout 单元

考虑神经网络的第$l$层：

$$ \begin{align*} \quad \zv_l & = \Wv_l \av_{l-1} + \bv_l \\ \av_l & = h_l (\zv_l) \end{align*} $$

前面提到的激活函数都是$\Rbb \mapsto \Rbb$的，即$[\av_l]_i = h_l ([\zv_l]_i), ~ i \in [n_l]$

Maxout 单元是$\Rbb^{n_l} \mapsto \Rbb$的，输入就是$\zv_l$，其定义为

$$ \begin{align*} \quad \maxout (\zv) = \max_{k \in [K]} \{ \wv_k^\top \zv + b_k \} \end{align*} $$

• 整体学习输入到输出间的非线性关系
• $\relu(z) = \max \{ 0, z \}$与$\lrelu(z) \overset{\gamma < 1}{=} \max \{ z, \gamma z \}$都是 Maxout 单元的特例

应用到机器学习

前$L-1$层是复合函数$\psi: \Rbb^d \mapsto \Rbb^{n_{L-1}}$，可看作一种特征变换方法

最后一层是学习器$\hat{\yv} = g(\psi(\xv); \Wv_L, \bv_L)$，对输入进行预测

• 若$y \in \{ \pm 1 \} \text{ or } \{ 1,0 \}$，最后一层只需$1$个神经元，采用对率激活函数
• 若$y \in [c]$，最后一层需$c$个神经元，采用 Softmax 激活函数

对率回归也可看作只有一层(没有隐藏层)的神经网络

深度学习

传统机器学习：特征工程和模型学习两阶段分开进行

深度学习：特征工程和模型学习合二为一，端到端 (end-to-end)

求解参数

整个网络：$\xv = \av_0 \xrightarrow{\Wv_1,\bv_1} \zv_1 \xrightarrow{h_1} \av_1 \xrightarrow{\Wv_2,\bv_2} \cdots \xrightarrow{\Wv_L,\bv_L} \zv_L \xrightarrow{h_L} \av_L = \hat{\yv}$

神经网络的优化目标为

$$ \begin{align*} \quad \min_{\Wv, \bv} ~ \frac{1}{m} \sum_{i \in [m]} \ell (\yv_i, \hat{\yv}_i) \end{align*} $$

其中损失$\ell (\yv, \hat{\yv})$的计算为正向传播

• 样本从输入层进入，经隐藏层逐层传播到最后输出层
• $\hat{\yv} = \av_L = h_L (\zv_L)$是对样本$\xv$的预测，据此计算$\ell (\yv, \hat{\yv}) = \ell (\yv, h_L (\zv_L))$

梯度下降更新公式为

$$ \begin{align*} \quad \Wv ~ \leftarrow ~ \Wv - \frac{\eta}{m} \sum_{i \in [m]} \class{yellow}{\frac{\partial \ell (\yv_i, \hat{\yv}_i)}{\partial \Wv}}, \quad \bv ~ \leftarrow ~ \bv - \frac{\eta}{m} \sum_{i \in [m]} \class{yellow}{\frac{\partial \ell (\yv_i, \hat{\yv}_i)}{\partial \bv}} \end{align*} $$

求解参数

整个网络：$\xv = \av_0 \xrightarrow{\Wv_1,\bv_1} \zv_1 \xrightarrow{h_1} \av_1 \xrightarrow{\Wv_2,\bv_2} \cdots \xrightarrow{\Wv_L,\bv_L} \zv_L \xrightarrow{h_L} \av_L = \hat{\yv}$

最后一层$\zv_L = \Wv_L ~ \av_{L-1} + \bv_L$，$\av_L = h_L (\zv_L)$，由链式法则有

$$ \begin{align*} \quad \frac{\partial \ell (\yv, \hat{\yv})}{\partial \bv_L} & = \frac{\partial \ell (\yv, \hat{\yv})}{\partial \zv_L} \frac{\partial \zv_L}{\partial \bv_L} = \deltav_L^\top \frac{\partial \zv_L}{\partial \bv_L} = \deltav_L^\top \\ \frac{\partial \ell (\yv, \hat{\yv})}{\partial \Wv_L} & = \sum_{j \in [n_L]} \frac{\partial \ell (\yv, \hat{\yv})}{\partial [\zv_L]_j} \frac{\partial [\zv_L]_j}{\partial \Wv_L} = \sum_{j \in [n_L]} [\deltav_L]_j \frac{\partial [\zv_L]_j}{\partial \Wv_L} \end{align*} $$

其中$\deltav_L^\top = \partial \ell (\yv, \hat{\yv}) / \partial \zv_L \in \Rbb^{n_L}$为第$L$层的误差项，可直接求解

类似的，对第$l$层$\zv_l = \Wv_l \av_{l-1} + \bv_l$，$\av_l = h_l (\zv_l)$，由链式法则有

$$ \begin{align*} \quad \frac{\partial \ell (\yv, \hat{\yv})}{\partial \bv_l} = \deltav_l^\top, \quad \frac{\partial \ell (\yv, \hat{\yv})}{\partial \Wv_l} = \sum_{j \in [n_l]} [\deltav_l]_j \frac{\partial [\zv_l]_j}{\partial \Wv_l} \end{align*} $$

其中$\deltav_l^\top = \partial \ell (\yv, \hat{\yv}) / \partial \zv_l \in \Rbb^{n_l}$为第$l$层的误差项

反向传播

反向传播 (backpropagation, BP)：前一层误差由后一层得到

$$ \begin{align*} \quad \deltav_{l-1}^\top = \frac{\partial \ell (\yv, \hat{\yv})}{\partial \zv_{l-1}} = \frac{\partial \ell (\yv, \hat{\yv})}{\partial \zv_l} \frac{\partial \zv_l}{\partial \av_{l-1}} \frac{\partial \av_{l-1}}{\partial \zv_{l-1}} = \deltav_l^\top \Wv_l \frac{\partial h_{l-1}(\zv_{l-1})}{\partial \zv_{l-1}} \end{align*} $$

最后对第$l$层$\zv_l = \Wv_l \av_{l-1} + \bv_l$，如何求$\partial [\zv_l]_j / \partial \Wv_l$？

注意$[\zv_l]_j = \sum_k [\Wv_l]_{jk} [\av_{l-1}]_k + [\bv_l]_j$只与$\Wv_l$的第$j$行有关，于是

$$ \begin{align*} \quad & \frac{\partial [\zv_l]_j}{\partial \Wv_l} = \underbrace{\begin{bmatrix} \zerov, \ldots, \av_{l-1}, \ldots, \zerov \end{bmatrix}}_{\text{only }\av_{l-1}\text{ at }j\text{-th column}} = \av_{l-1} \ev_j^\top \\[4pt] \quad & \Longrightarrow \frac{\partial \ell (\yv, \hat{\yv})}{\partial \Wv_l} = \sum_{j \in [n_l]} [\deltav_l]_j \frac{\partial [\zv_l]_j}{\partial \Wv_l} = \av_{l-1} \sum_{j \in [n_l]} [\deltav_l]_j \ev_j^\top = \av_{l-1} \deltav_l^\top \end{align*} $$

反向传播算法

输入：训练集，验证集，相关超参数

1. 随机初始化$\Wv$和$\bv$
2. while 神经网络在验证集上的精度仍在上升
3.   对训练集中的样本随机重排序
4.   for $i = 1, \ldots, m$ do
5.     获取样本$(\xv_i, \yv_i)$
6.     正向传播，依次计算$\av_l = h_l(\Wv_l \av_{l-1} + \bv_l)$，最后得到$\ell (\yv_i, \hat{\yv}_i)$
7.     反向传播，依次计算误差项$\deltav_l^\top = \deltav_{l+1}^\top \Wv_{l+1} \diag (h_l'(\zv_l))$
8.     计算梯度$\partial \ell (\yv_i, \hat{\yv}_i) / \partial \Wv_l = \av_{l-1} \deltav_l^\top$、$\partial \ell (\yv_i, \hat{\yv}_i) / \partial \bv_l = \deltav_l^\top$
9.     采用梯度下降更新$\Wv_l$和$\bv_l$

输出：$\Wv$和$\bv$

sklearn 中的神经网络

import numpy as np
from sklearn.neural_network import MLPClassifier

mlp = MLPClassifier(
    hidden_layer_sizes=(h),    # 隐藏层神经元个数
    activation='logistic',     # identity, logistic, tanh, relu
    max_iter=100,              # 最大迭代轮数
    solver='lbfgs',            # 求解器
    alpha=0,                   # 正则项系数
    batch_size=32,             # 批量大小
    learning_rate='constant',  # constant, invscaling, adaptive
    shuffle=True,              # 每轮是否将样本重新排序,
    momentum=0.9,              # 动量法系数, sgd only
    nesterovs_momentum=True,   # 动量法用Nesterov加速
    early_stopping=False,      # 是否提早停止
    warm_start=False,          # 是否开启热启动机制
    random_state=1,
    verbose=False
    ...
)

clf = mlp.fit(X, y)
acc = clf.score(X, y)

sklearn 中的神经网络

• 以异或 4 个点为中心，从 2 维高斯分布中各采样 255 个样本
• 单隐藏层，对率激活函数，lbfgs 求解器

sklearn 中的神经网络

• 以异或 4 个点为中心，从 2 维高斯分布中各采样 255 个样本
• 单隐藏层，3 个神经元，lbfgs 求解器

sklearn 中的神经网络

• 以异或 4 个点为中心，从 2 维高斯分布中各采样 255 个样本
• 单隐藏层，7 个神经元，ReLU 激活函数

用 TensorFlow 实现

from tensorflow.keras.layers import Dense
from tensorflow.keras.models import Sequential
from tensorflow.keras.optimizers import Adam

model = Sequential()
model.add(Dense(units=3, activation="sigmoid", input_shape=(2, )))
model.add(Dense(units=1, activation='sigmoid'))

model.summary()  # 打印模型
_________________________________________________________________
 Layer (type)                Output Shape              Param #
=================================================================
 dense (Dense)               (None, 3)                 9

 dense_1 (Dense)             (None, 1)                 4

=================================================================
Total params: 13
Trainable params: 13
Non-trainable params: 0
_________________________________________________________________

model.compile(
    optimizer=Adam(0.1),
    loss="binary_crossentropy",
    metrics=['accuracy']
)

model.fit(X, y, epochs=10, batch_size=32)
Epoch 1/10
32/32 [==============] - 0s 1ms/step - loss: 0.6481 - accuracy: 0.6309
Epoch 2/10
32/32 [==============] - 0s 1ms/step - loss: 0.5064 - accuracy: 0.7500
Epoch 3/10
32/32 [==============] - 0s 1000us/step - loss: 0.3309 - accuracy: 0.8369
Epoch 4/10
32/32 [==============] - 0s 1ms/step - loss: 0.1383 - accuracy: 1.0000
Epoch 5/10
32/32 [==============] - 0s 1ms/step - loss: 0.0643 - accuracy: 1.0000
Epoch 6/10
32/32 [==============] - 0s 1ms/step - loss: 0.0395 - accuracy: 1.0000
Epoch 7/10
32/32 [==============] - 0s 1ms/step - loss: 0.0276 - accuracy: 1.0000
Epoch 8/10
32/32 [==============] - 0s 1ms/step - loss: 0.0208 - accuracy: 1.0000
Epoch 9/10
32/32 [==============] - 0s 994us/step - loss: 0.0165 - accuracy: 1.0000
Epoch 10/10
32/32 [==============] - 0s 997us/step - loss: 0.0134 - accuracy: 1.0000

loss, acc = model.evaluate(X, y, verbose=2)
32/32 - 0s - loss: 0.0121 - accuracy: 1.0000 - 93ms/epoch - 3ms/step

用 TensorFlow 实现

• 以异或 4 个点为中心，从 2 维高斯分布中各采样 255 个样本
• 单隐藏层，对率激活函数，Adam 求解器

梯度消失

神经网络中误差反向传播的迭代公式为

$$ \begin{align*} \quad \deltav_l^\top = \frac{\partial \ell (\yv, \hat{\yv})}{\partial \zv_l} = \frac{\partial \ell (\yv, \hat{\yv})}{\partial \zv_{l+1}} \frac{\partial \zv_{l+1}}{\partial \av_l} \frac{\partial \av_l}{\partial \zv_l} = \deltav_{l+1}^\top \Wv_{l+1} \diag (h_l'(\zv_l)) \end{align*} $$

对于 Sigmoid 型激活函数

• $\nabla \sigma(z) = \sigma(z) (1 - \sigma(z)) \le 1/4$
• $\nabla \tanh(z) = 4 \sigma(2z) (1 - \sigma(2z)) \le 1$

误差每传播一层都会乘以一个小于等于$1$的系数，当网络层数很深时，梯度会不断衰减甚至消失，使得整个网络很难训练

解决方案：使用导数比较大的激活函数，比如 ReLU

残差网络

残差模块 $\zv_l = \av_{l-1} + \class{yellow}{\Uv_2 \cdot h(\Uv_1 \cdot \av_{l-1} + \cv_1) + \cv_2} = \av_{l-1} + \class{yellow}{f(\av_{l-1})}$

假设$\av_l = \zv_l$，即残差模块输出不使用激活函数，对$\forall t \in [l]$有

$$ \begin{align*} \quad \av_l = \av_{l-1} + f(\av_{l-1}) = \av_{l-2} + f(\av_{l-2}) + f(\av_{l-1}) = \cdots = \av_{l-t} + \sum_{i=l-t}^{l-1} f(\av_i) \end{align*} $$

低层输入可以恒等传播到任意高层

残差网络

低层输入可以恒等传播到任意高层

$$ \begin{align*} \quad \av_l = \av_{l-t} + \sum_{i=l-t}^{l-1} f(\av_i) \end{align*} $$

由链式法则有

$$ \begin{align*} \quad \frac{\partial \ell}{\partial \av_{l-t}} & = \frac{\partial \ell}{\partial \av_l} \frac{\partial \av_l}{\partial \av_{l-t}} = \frac{\partial \ell}{\partial \av_l} \left( \frac{\partial \av_{l-t}}{\partial \av_{l-t}} + \frac{\partial }{\partial \av_{l-t}} \sum_{i=l-t}^{l-1} f(\av_i) \right) \\ & = \frac{\partial \ell}{\partial \av_l} \left( \Iv + \frac{\partial }{\partial \av_{l-t}} \sum_{i=l-t}^{l-1} f(\av_i) \right) \\ & = \frac{\partial \ell}{\partial \av_l} + \frac{\partial \ell}{\partial \av_l} \left( \frac{\partial }{\partial \av_{l-t}} \sum_{i=l-t}^{l-1} f(\av_i) \right) \end{align*} $$

高层误差可以恒等传播到任意低层，梯度消失得以缓解

卷积神经网络

图像数据集 ImageNet：

• 共有 14,197,122 训练图片、50,000 验证图片、100,000 测试图片
• 共有 1,000 个类别，通过众包进行标注
• 图片分辨率：256 × 256、224 × 224、299 × 299

用全连接网络训练 ImageNet

• 图片全部裁减到 224 × 224，输入层神经元个数为 50,176
• 共有 1,000 个类别，输出层神经元个数为 1,000
• 假设只有一个隐藏层，神经元个数取个折中 10,000

总参数量为 (50,176 + 1,000) × 10,000 = 511,760,000

• 训练效率非常低
• 很容易出现过拟合

局部连接 权值共享

局部连接：每个神经元只与前一层确定数量的 (远小于总数) 神经元相连

权值共享：确定数量的神经元均采用相同的输入权重系数

限制神经元的输入权重个数，降低参数规模，降低模型复杂度

局部连接 权值共享

$$ \begin{align*} \qquad \qquad \qquad \qquad a_1 & = x_1 \times w_1 + x_2 \times w_2 + x_3 \times w_3 \\ a_2 & = x_2 \times w_1 + x_3 \times w_2 + x_4 \times w_3 \\ a_3 & = x_3 \times w_1 + x_4 \times w_2 + x_5 \times w_3 \\ a_4 & = x_4 \times w_1 + x_5 \times w_2 + x_6 \times w_3 \end{align*} $$

卷积神经网络：局部连接，权值共享

一维卷积

$$ \begin{align*} \quad (f \otimes g) [n] = \sum_{m = -\infty}^\infty f[m] \cdot g[n-m] \end{align*} $$

取$f[i] = x_i$，$g[-2] = w_3$，$g[-1] = w_2$，$g[0] = w_1$，其余为零

$$ \begin{align*} \quad a_n = x_n w_1 + x_{n+1} w_2 + x_{n+2} w_3 = \sum_{m = -\infty}^\infty f[m] \cdot g[n-m] = (f \otimes g) [n] \end{align*} $$

二维卷积

针对输入是矩阵的情形

参与卷积的深色区域称为对应输出神经元的感受野 (receptive field)

二维卷积 图像滤波

平滑去噪

$\otimes ~ \begin{bmatrix} \frac{1}{9} & \frac{1}{9} & \frac{1}{9} \\ \frac{1}{9} & \frac{1}{9} & \frac{1}{9} \\ \frac{1}{9} & \frac{1}{9} & \frac{1}{9} \end{bmatrix} ~ =$

二维卷积 图像滤波

边缘提取

$\otimes ~ \begin{bmatrix} 0 & 1 & 1 \\ -1 & 0 & 1 \\ -1 & -1 & 0 \end{bmatrix} ~ = $

经典网络 LeNet-5

LeNet-5 手写数字识别

import numpy as np
import tensorflow as tf
from tensorflow.keras import Sequential
from tensorflow.keras.datasets.mnist import load_data
from tensorflow.keras.layers import (Conv2D, Dense, Dropout,
                                     Flatten, AveragePooling2D)
from tensorflow.keras.optimizers import Adam

(x_train, y_train), (x_test, y_test) = load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
x_train = np.expand_dims(x_train, -1)
x_test = np.expand_dims(x_test, -1)

model = Sequential()
model.add(Conv2D(6, (5, 5), activation="relu",
                 padding="same", input_shape=(28, 28, 1)))
model.add(AveragePooling2D(pool_size=(2, 2)))
model.add(Conv2D(16, (5, 5), activation="relu"))
model.add(AveragePooling2D(pool_size=(2, 2)))
model.add(Conv2D(120, (5, 5), activation="relu"))
model.add(Flatten())
model.add(Dense(84, activation="relu"))
model.add(Dense(10, activation="softmax"))
model.summary()
# Model: "sequential"
# _________________________________________________________________
#  Layer (type)                Output Shape              Param #   
# =================================================================
#  conv2d (Conv2D)             (None, 28, 28, 6)         156       
#                                                                  
#  average_pooling2d (AverageP  (None, 14, 14, 6)        0         
#  ooling2D)                                                       
#                                                                  
#  conv2d_1 (Conv2D)           (None, 10, 10, 16)        2416      
#                                                                  
#  average_pooling2d_1 (Averag  (None, 5, 5, 16)         0         
#  ePooling2D)                                                     
#                                                                  
#  conv2d_2 (Conv2D)           (None, 1, 1, 120)         48120     
#                                                                  
#  flatten (Flatten)           (None, 120)               0         
#                                                                  
#  dense (Dense)               (None, 84)                10164     
#                                                                  
#  dense_1 (Dense)             (None, 10)                850       
#                                                                  
# =================================================================
# Total params: 61,706
# Trainable params: 61,706
# Non-trainable params: 0

model.compile(
    optimizer=Adam(0.001),
    loss="sparse_categorical_crossentropy",
    metrics=["accuracy"]
)

model.fit(x_train, y_train, epochs=5, verbose=1)
# Epoch 1/5
# 1875/1875 [==============================] - 7s 2ms/step - loss: 0.2085 - accuracy: 0.9356 
# Epoch 2/5
# 1875/1875 [==============================] - 4s 2ms/step - loss: 0.0657 - accuracy: 0.9795
# Epoch 3/5
# 1875/1875 [==============================] - 4s 2ms/step - loss: 0.0479 - accuracy: 0.9844
# Epoch 4/5
# 1875/1875 [==============================] - 4s 2ms/step - loss: 0.0372 - accuracy: 0.9886
# Epoch 5/5
# 1875/1875 [==============================] - 4s 2ms/step - loss: 0.0300 - accuracy: 0.9907

model.evaluate(x_test, y_test, verbose=2)
# 313/313 - 1s - loss: 0.0409 - accuracy: 0.9860 - 536ms/epoch - 2ms/step